LIN_UART.c

Go to the documentation of this file.

#include "derivative.h"
#include "Compile_Options.h"
#include "LIN_UART.h"
/*
 ******************************************************************************
 * Constants
 ******************************************************************************
 */
static const LINFLEX_t catLINUARTInstances[] = 
{
  &(LINFLEX_0), &(LINFLEX_1), &(LINFLEX_2), &(LINFLEX_3)
};
/*
 ******************************************************************************
 * Globals
 ******************************************************************************
 */
vuint8_t gau8LINUARTWordsTx[N_LIN_INSTANCES];
vuint8_t gau8LINUARTWordsRx[N_LIN_INSTANCES];
vuint8_t gau8LINUARTRxFlagHasBeenClearedByTx[N_LIN_INSTANCES];
static vuint8_t   gau8LINUARTPhysicalBufferSize[N_LIN_INSTANCES];
vuint8_t* gpu8LINUARTTxBuffer[N_LIN_INSTANCES];
vuint8_t* gpu8LINUARTRxBuffer[N_LIN_INSTANCES];
/*
 ******************************************************************************
 * u8fnUARTWrite
 ******************************************************************************
 */
uint8_t u8fnUARTWrite(const uint8_t u8Instance, const uint8_t* pu8UARTTx, \
                      const uint8_t u8Size)
{
  /* Declare local variables */
  uint8_t u8Status;
  
  /* We will init our local variable by starting a transmission */
  u8Status = u8fnLINUARTSend(u8Instance, pu8UARTTx, u8Size);
  
  if(CLEAR == u8Status)
  {
    /* If our transmission started, we will now wait for it to finish */
    u8Status = u8fnWaitForUARTTxBufferToEmpty(u8Instance, SCI_TIME_OUT);
    /* And once we're done, we will stop the HW */
    vfnEnableLINRxISR(u8Instance, CLEAR); 
  }
  else
  {
    /* Nothing */
  }
  
  return(u8Status);
}
/*
 ******************************************************************************
 * u8fnUARTRead
 ******************************************************************************
 */
uint8_t u8fnUARTRead(const uint8_t u8Instance, const uint8_t* pu8UARTRx, \
                     const uint8_t u8Size)
{
  /* Locals */
  uint32_t  u32TimeOut;
  uint8_t   u8Status;
  
  /* Init locals */
  u32TimeOut = CLEAR;
  /* Also receive data using interrupts */
  u8Status = u8fnLINUARTReceive(u8Instance, pu8UARTRx, TRUE);
  
  if(CLEAR == u8Status)
  {
    do
    {
      /* Wait here */
      u32TimeOut++;
    }while((SCI_TIME_OUT != u32TimeOut) && 
           (u8Size > gau8LINUARTWordsRx[u8Instance]));
    
    /* Why did we exit the loop ? */
    if(CLEAR == u32TimeOut)
    {
      u8Status = UART_TIMEOUT;
    }
    else
    {
      /* We're good */
    }
  }
  else
  {
    /* Nothing */
  }
  
  return(u8Status);
}
/*
 ******************************************************************************
 * u8fnLINUARTSend
 ******************************************************************************
 */
uint8_t u8fnLINUARTSend(const uint8_t u8Instance, const uint8_t* pu8UARTTx, \
                        const uint8_t u8Size)
{
  /* Locals */
  uint8_t u8Status;
  
  u8Status = CLEAR;
  
 /* Only proceed if there's no pending operation & we are not in config mode */
  if((CLEAR == gau8LINUARTWordsTx[u8Instance]) && \
     (LIN_INIT != u8fnReturnLINSMMode(u8Instance)))
  {
    /* Assign buffers to globals and enable interrupts */
    gau8LINUARTWordsTx[u8Instance] = u8Size;
    gpu8LINUARTTxBuffer[u8Instance] = (vuint8_t*)pu8UARTTx;
    
    /* Enable Data Transmission Done Interrupt */
    vfnEnableLINTxISR(u8Instance, TRUE);
    
    /* Transmit the first set of data */
    u8Status = u8fnLINUARTSetTxData(u8Instance);
  }
  else
  {
    u8Status = UART_NOT_READY;
  }
  
  return(u8Status);
}
/*
 ******************************************************************************
 * u8fnLINUARTReceive
 ******************************************************************************
 */
uint8_t u8fnLINUARTReceive(const uint8_t u8Instance, const uint8_t* pu8UARTRx, 
                           const uint8_t u8IsrEn)
{
  /* Locals */
  uint8_t u8Status;

  u8Status = CLEAR;
 /* Only proceed if we are not in config mode */
  if(LIN_INIT != u8fnReturnLINSMMode(u8Instance))
  {
    /* Start by clearing how many bytes we have */
    gau8LINUARTWordsRx[u8Instance] = CLEAR;
    
    /* Now tell the global variable where to write received data */
    gpu8LINUARTRxBuffer[u8Instance] = (vuint8_t*)pu8UARTRx;
    
    /* Enable Rx Data Reception Complete Interrupt */
    vfnEnableLINRxISR(u8Instance, u8IsrEn);  
  }
  else
  {
    u8Status = UART_NOT_READY;
  }
  
  return(u8Status);
}
/*
 ******************************************************************************
 * u8fnConfigLINUARTGeneral
 ******************************************************************************
 */
uint8_t u8fnConfigLINUARTGeneral(const LINUARTConfig_t* tLINUARTConfig)
{
  /* Declare locals */
  uint8_t   u8Status;
  uint8_t   u8Instance;
  LINFLEX_t tMyLINFLEX;
  
  /* Init locals */
  u8Status   = CLEAR;
  u8Instance = (uint8_t)tLINUARTConfig->P.Instance;
  
  /* Before anything can happen, we need to know to what instance we're      */
  /* going to talk to.                                                       */
  tMyLINFLEX = catLINUARTInstances[u8Instance];
  
  /* We need to go into INIT */
  u8Status = u8fnChangeSMModeLINUART(u8Instance, (uint8_t)LIN_INIT);
  if(CLEAR == u8Status)
  {
    /* Configure the module as an UART before continuing */
    tMyLINFLEX->UARTCR.B.UART = TRUE;
    
    /* Enable transmission and reception */
    tMyLINFLEX->UARTCR.B.TXEN = TRUE;
    tMyLINFLEX->UARTCR.B.RXEN = TRUE;
    
    /* Set the baud-rate */
    tMyLINFLEX->LINFBRR.B.DIV_F = tLINUARTConfig->P.BaudRateFraction;
    tMyLINFLEX->LINIBRR.B.DIV_M = tLINUARTConfig->P.BaudRateMantissa;
    
    /* Set buffer sizes */
    tMyLINFLEX->UARTCR.B.TDFL = tLINUARTConfig->P.TxBufferSize;
    tMyLINFLEX->UARTCR.B.RDFL = tLINUARTConfig->P.RxBufferSize;
    
    /* Also, remember these */
    gau8LINUARTPhysicalBufferSize[u8Instance] = (uint8_t)\
             (((tLINUARTConfig->P.TxBufferSize + 1u) << BITS_IN_NIBBLE) | \
              (tLINUARTConfig->P.RxBufferSize + 1u));
    
    /* Set Parity checks */
    tMyLINFLEX->UARTCR.B.OP  = tLINUARTConfig->P.OddParityEn;
    tMyLINFLEX->UARTCR.B.PCE = tLINUARTConfig->P.ParityCheckEn;
    
    /* Set Word Size */
    tMyLINFLEX->UARTCR.B.WL  = tLINUARTConfig->P.WordSizeIs8Bits;
    
    
    if(TRUE == tLINUARTConfig->P.Enable)
    {
      u8Status = u8fnChangeSMModeLINUART(u8Instance, \
                                                  (uint8_t)LIN_IDLE);
      /* Make sure that the counters are set to 0 */
      gau8LINUARTWordsTx[u8Instance] = CLEAR;
      gau8LINUARTWordsRx[u8Instance]  = CLEAR;
    }
    else
    {
      /* Stay in current mode, and disable TX AND RX */
      tMyLINFLEX->UARTCR.B.TXEN = CLEAR;
      tMyLINFLEX->UARTCR.B.RXEN = CLEAR;
    }
  }
  else
  {
    /* Nothing, exit and flag */
  }
  
  return(u8Status);
}
/*
 ******************************************************************************
 * u8fnLINUARTSetTxData
 ******************************************************************************
 */
static uint8_t u8fnLINUARTSetTxData(uint8_t u8Instance)
{
  /* Declare locals */
  uint8_t   u8Status;
  uint8_t   u8UARTBufferSize;
  
  /* Init locals */
  u8Status = CLEAR;
  
  /* Define what the buffer size for the UART is: we'll need this later */
  u8UARTBufferSize = gau8LINUARTPhysicalBufferSize[u8Instance] >> BITS_IN_NIBBLE;
  
  if(CLEAR < gau8LINUARTWordsTx[u8Instance] / u8UARTBufferSize)
  {
    u8Status = u8fnLINWriteTxBuffer(u8Instance, u8UARTBufferSize);
  }/* End of IF */
  else
  {
    /* We need to redefine the size of our Buffer size */
    u8UARTBufferSize = gau8LINUARTWordsTx[u8Instance];
    
    /* And we need to feed this new size to our buffer */
    if(CLEAR == u8fnChangeSMModeLINUART(u8Instance, (uint8_t)LIN_INIT))
    {
      catLINUARTInstances[u8Instance]->UARTCR.B.TDFL = u8UARTBufferSize - 1u;
      if(CLEAR == u8fnChangeSMModeLINUART(u8Instance, (uint8_t)LIN_DATA_TX_RX))
      {
        u8Status = u8fnLINWriteTxBuffer(u8Instance, u8UARTBufferSize);
      }
      else
      {
        u8Status = UART_NOT_READY;
      }
    }
    else
    {
      /* Flag it as an error and exit */
      u8Status = UART_NOT_READY;
    }
  }/* End of ELSE */
  
  return(u8Status);
}
/*
 ******************************************************************************
 * u8fnLINUARTGetDataNoIsr
 ******************************************************************************
 */
uint8_t u8fnLINUARTGetDataNoIsr(uint8_t u8Instance)
{
  /* used to get data without using ISRs */
  /* Locals */
  uint8_t u8Status;
  
  /* Init locals */
  u8Status = CLEAR;
  
  /* Since the receive flag is also cleared when the Tx flag is cleared, */
  /* we will check both for the state of the HW flag and a SW flag set   */
  /* by the Tx Isr in case this happens.                                 */
  if((catLINUARTInstances[u8Instance]->UARTSR.B.DRF == TRUE) || 
      (gau8LINUARTRxFlagHasBeenClearedByTx[u8Instance] == TRUE))
  {
    /* Clear flags */
    catLINUARTInstances[u8Instance]->UARTSR.B.DRF = TRUE;
    gau8LINUARTRxFlagHasBeenClearedByTx[u8Instance] = CLEAR;
    
    /* Get data */
    u8Status = u8fnLINUARTGetRxData(u8Instance);
  }
  else
  {
    u8Status = UART_NO_DATA_RX;
  }
  return(u8Status);
}
/*
 ******************************************************************************
 * u8fnLINUARTGetRxData
 ******************************************************************************
 */
static uint8_t u8fnLINUARTGetRxData(uint8_t u8Instance)
{
  /* Declare locals */
  uint8_t   u8Status;
  uint8_t   u8UARTBufferSize;
  int8_t    i8Counter;
  LINFLEX_t tMyLINFLEX;
  
  /* Init locals */
  u8Status = CLEAR;
  
  /* Before anything can happen, we need to know to what instance we're      */
  /* going to talk to.                                                       */
  tMyLINFLEX = catLINUARTInstances[u8Instance];
  
  /* Define what the buffer size for the UART is: we need this to know how   */
  /* many bytes we need to transfer into RAM.                                */
  u8UARTBufferSize = (gau8LINUARTPhysicalBufferSize[u8Instance] & 0x0F);
  
  if((CLEAR < u8UARTBufferSize) && (UART_PHYSICAL_BUFF_SIZE >= u8UARTBufferSize))
  {
    for(i8Counter = CLEAR; i8Counter < u8UARTBufferSize; i8Counter++)
    {
      switch(i8Counter)
      {
        case (UART_BUFF3):
        {
          *gpu8LINUARTRxBuffer[u8Instance] = (uint8_t)tMyLINFLEX->BDRM.B.DATA7;
          break;
        }
        case (UART_BUFF2):
        {
          *gpu8LINUARTRxBuffer[u8Instance] = (uint8_t)tMyLINFLEX->BDRM.B.DATA6;
          break;
        }
        case (UART_BUFF1):
        {
          *gpu8LINUARTRxBuffer[u8Instance] = (uint8_t)tMyLINFLEX->BDRM.B.DATA5;
          break;
        }
        case (UART_BUFF0):
        {
          *gpu8LINUARTRxBuffer[u8Instance] = (uint8_t)tMyLINFLEX->BDRM.B.DATA4;
          break;
        }
        default:
        {
          u8Status = UART_INVALID_BUFFER_SIZE;
          break;
        }
      };
      
      /* Increment pointer & counter of bytes received */
      gpu8LINUARTRxBuffer[u8Instance]++;
      gau8LINUARTWordsRx[u8Instance]++;
    }
  }
  else
  {
    u8Status = UART_INVALID_BUFFER_SIZE;
  }
  
  return(u8Status);
}
/*
 ******************************************************************************
 * u8fnLINWriteTxBuffer
 ******************************************************************************
 */
static uint8_t u8fnLINWriteTxBuffer(const uint8_t u8Instance, 
                                    const uint8_t u8UARTBufferSize)
{
  /* Local variables */
  uint8_t   u8Status;
  uint32_t  u32ValueToWrite;
  uint8_t   u8Counter;

  /* Init locals */
  u8Status = CLEAR;
  u32ValueToWrite = CLEAR;
  
  /* The whole register is written in one operation - we need to comply */
  if((CLEAR < u8UARTBufferSize) && (UART_PHYSICAL_BUFF_SIZE > u8UARTBufferSize))
  {
    /* Write each byte into a 32-bit word */
    for(u8Counter = CLEAR; u8Counter < u8UARTBufferSize; u8Counter++)
    {
      u32ValueToWrite |= (*gpu8LINUARTTxBuffer[u8Instance] << 
                          (u8Counter * BITS_IN_BYTE));

      gpu8LINUARTTxBuffer[u8Instance]++;
      gau8LINUARTWordsTx[u8Instance]--;
    }
    
    catLINUARTInstances[u8Instance]->BDRL.R = u32ValueToWrite;
  }
  else
  {
    u8Status = UART_INVALID_BUFFER_SIZE;
  }
  
  return(u8Status);
}
/*
 ******************************************************************************
 * u8fnWaitForUARTTxBufferToEmpty
 ******************************************************************************
 */
uint8_t u8fnWaitForUARTTxBufferToEmpty(uint8_t u8Instance, uint32_t u32TimeOut)
{
  /* Local variables */
  uint8_t u8Status;
  
  /* Init locals */
  u8Status = CLEAR;
  
  do
  {
    /* Wait here */
    u32TimeOut--;
  }while((CLEAR < u32TimeOut) && \
         (CLEAR != u8fnReturnLINTxISRStatus(u8Instance)));
  
  /* Flag if we came out because of a time out */
  if(CLEAR == u32TimeOut)
  {
    u8Status = UART_TIMEOUT;
  }
  else
  {
    /* Exit without errors */
  }
  
  return(u8Status);
}
/*
 ******************************************************************************
 * u8fnSelectLINInstance
 ******************************************************************************
 */
static uint8_t u8fnReturnLINSMMode(const uint8_t u8Instance)
{  
  return((uint8_t)(catLINUARTInstances[u8Instance]->LINSR.B.LINS));
}
/*
 ******************************************************************************
 * u8fnChangeSMModeLINUART
 ******************************************************************************
 */
static uint8_t u8fnChangeSMModeLINUART(const uint8_t u8Instance, \
                                       const uint8_t u8Mode)
{
  uint8_t u8Status;
  uint8_t u8CurrentMode;
  LINFLEX_t tMyLINFLEX;
  
  u8Status = CLEAR;
  
  /* Before anything can happen, we need to know to what instance we're      */
  /* going to talk to.                                                       */
  tMyLINFLEX = catLINUARTInstances[u8Instance];
  
  u8CurrentMode = u8fnReturnLINSMMode(u8Instance);
  
  /* Switch depending on what mode we're at and where we want to go.         */
  /* Note that "NORMAL" mode are is flaged as "asleep" when in UART.         */
  if(LIN_ASLEEP == u8CurrentMode)
  {
    if(LIN_INIT == u8Mode)
    {
      tMyLINFLEX->LINCR1.B.SLEEP = CLEAR;
      tMyLINFLEX->LINCR1.B.INIT  = TRUE;
    }
    else
    {
      u8Status = u8CurrentMode;
    }
  }
  else if(LIN_INIT == u8CurrentMode)
  {
    if(LIN_ASLEEP == u8Mode) 
    {
      tMyLINFLEX->LINCR1.B.SLEEP = TRUE;
    }
    else if (LIN_INIT == u8Mode)
    {
      u8Status = u8CurrentMode;
    }
    else
    {
      tMyLINFLEX->LINCR1.R = (tMyLINFLEX->LINCR1.B.SLEEP & 0xFFFC) | CLEAR;
      //tMyLINFLEX->LINCR1.B.INIT  = CLEAR;
      //tMyLINFLEX->LINCR1.B.SLEEP = CLEAR;
    }
  }
  else
  {
    u8Status = u8CurrentMode;
  }
  
  return(u8Status);
}
/*
 ******************************************************************************
 * u8fnReturnLINTxISRStatus
 ******************************************************************************
 */
static uint8_t u8fnReturnLINTxISRStatus(uint8_t u8Instance)
{
  
  return((uint8_t)(catLINUARTInstances[u8Instance]->LINIER.B.DTIE));
}
/*
 ******************************************************************************
 * u8fnReturnLINRxISRStatus
 ******************************************************************************
 */
static uint8_t u8fnReturnLINRxISRStatus(uint8_t u8Instance)
{
  return((uint8_t)(catLINUARTInstances[u8Instance]->LINIER.B.DRIE));
}
/*
 ******************************************************************************
 * vfnEnableLINTxISR
 ******************************************************************************
 */
void vfnEnableLINTxISR(uint8_t u8Instance, uint8_t u8Switch)
{
  catLINUARTInstances[u8Instance]->LINIER.B.DTIE = (CLEAR < u8Switch);
  
  return;
}

/*
 ******************************************************************************
 * vfnEnableLINRxISR
 ******************************************************************************
 */
void vfnEnableLINRxISR(uint8_t u8Instance, uint8_t u8Switch)
{
  catLINUARTInstances[u8Instance]->LINIER.B.DRIE = (CLEAR < u8Switch);
  
  return;
}
/*
 ******************************************************************************
 * vfnGenericLINTxIsr
 ******************************************************************************
 */
static void vfnGenericLINTxIsr(uint8_t u8Instance)
{
  /* Local variables */
  LINFLEX_t tMyLINFLEX;
  
  
  /* Before anything can happen, we need to know to what instance we're      */
  /* going to talk to.                                                       */
  tMyLINFLEX = catLINUARTInstances[u8Instance];
  
  /* Clear the flag: Note that even though we're only writing to the DTF  */
  /* flag, this also clears the DRF flag. We must therefore handle any    */
  /* pending DRF as well. */
  if(tMyLINFLEX->UARTSR.B.DRF == TRUE)
  {
    gau8LINUARTRxFlagHasBeenClearedByTx[u8Instance] = TRUE;
  }
  else
  {
    gau8LINUARTRxFlagHasBeenClearedByTx[u8Instance] = CLEAR;
  }
  
  tMyLINFLEX->UARTSR.B.DTF = TRUE;
  
  /* Only transmit if we still have something in the buffer */
  if(CLEAR != gau8LINUARTWordsTx[u8Instance])
  {
    /* Place as many values in the UART buffer as possible */
    (void)u8fnLINUARTSetTxData(u8Instance);
  }
  else
  {
    /* We're done transmitting. Turn interrupts off */
    vfnEnableLINTxISR(u8Instance, CLEAR);
    
    /* Reconfigure UART buffer size to its default value */
    (void)u8fnChangeSMModeLINUART(u8Instance, LIN_INIT);
    tMyLINFLEX->UARTCR.B.TDFL = \
                        (gau8LINUARTPhysicalBufferSize[u8Instance] >> BITS_IN_NIBBLE) - 1u;
    (void)u8fnChangeSMModeLINUART(u8Instance, LIN_IDLE);
  }
  
  return;
}
/*
 ******************************************************************************
 * vfnLIN0TxIsr
 ******************************************************************************
 */
void vfnLIN0TxIsr(void)
{
  vfnGenericLINTxIsr(LIN_INSTANCE_0);
  return;
}
/*
 ******************************************************************************
 * vfnLIN1TxIsr
 ******************************************************************************
 */
void vfnLIN1TxIsr(void)
{
  vfnGenericLINTxIsr(LIN_INSTANCE_1);
  
  return;
}
/*
 ******************************************************************************
 * vfnLIN2TxIsr
 ******************************************************************************
 */
void vfnLIN2TxIsr(void)
{
  vfnGenericLINTxIsr(LIN_INSTANCE_2);
  
  return;
}
/*
 ******************************************************************************
 * vfnLIN3TxIsr
 ******************************************************************************
 */
void vfnLIN3TxIsr(void)
{
  vfnGenericLINTxIsr(LIN_INSTANCE_3);
  
  return;
}
/*
 ******************************************************************************
 * vfnGenericLINRxIsr
 ******************************************************************************
 */
static void vfnGenericLINRxIsr(uint8_t u8Instance)
{ 
  /* Put data in array */
  (void)u8fnLINUARTGetRxData(u8Instance);
  
  /* Since clearing the Rx flag also clears the Tx flag, we need to check */
  /* it here as well and send data if it's the case.                      */
  if(TRUE == catLINUARTInstances[u8Instance]->UARTSR.B.DTF)
  {
    /* Only transmit if we still have something in the buffer */
    if(CLEAR != gau8LINUARTWordsTx[u8Instance])
    {
      /* Place as many values in the UART buffer as possible */
      (void)u8fnLINUARTSetTxData(u8Instance);
    }
    else
    {
      /* We're done transmitting. Turn interrupts off */
      vfnEnableLINTxISR(u8Instance, CLEAR);
      
      /* Reconfigure UART buffer size to its default value */
      (void)u8fnChangeSMModeLINUART(u8Instance, LIN_INIT);
      catLINUARTInstances[u8Instance]->UARTCR.B.TDFL = \
                          (gau8LINUARTPhysicalBufferSize[u8Instance] >> BITS_IN_NIBBLE) - 1u;
      (void)u8fnChangeSMModeLINUART(u8Instance, LIN_IDLE);
    }
  }
  else
  {
    /* Nothing */
  }
  
  /* Clear the flag */
  catLINUARTInstances[u8Instance]->UARTSR.B.DRF = TRUE;
  
  
  
  return;
}
/*
 ******************************************************************************
 * vfnLIN0RxIsr
 ******************************************************************************
 */
void vfnLIN0RxIsr(void)
{
  vfnGenericLINRxIsr(LIN_INSTANCE_0);
  
  return;
}
/*
 ******************************************************************************
 * vfnLIN1RxIsr
 ******************************************************************************
 */
void vfnLIN1RxIsr(void)
{
  vfnGenericLINRxIsr(LIN_INSTANCE_1);
  
  return;
}
/*
 ******************************************************************************
 * vfnLIN2RxIsr
 ******************************************************************************
 */
void vfnLIN2RxIsr(void)
{
  vfnGenericLINRxIsr(LIN_INSTANCE_2);
  
  return;
}
/*
 ******************************************************************************
 * vfnLIN3RxIsr
 ******************************************************************************
 */
void vfnLIN3RxIsr(void)
{
  vfnGenericLINRxIsr(LIN_INSTANCE_3);
  
  return;
}
/*
 ******************************************************************************
 *
 *  End of file.
 *
 ******************************************************************************
 */